#pragma once

#include <string>
#include <memory>
#include <vector>

#include <rtc_base/ssl_fingerprint.h>

#include "codec_info.h"
#include "ice/ice_credentials.h"
#include "ice/candidate.h"

namespace xrtc {
    
// sdp类型    
enum class SdpType {
    k_offer = 0,
    k_answer = 1,
};

// 媒体类型（音频或视频）
enum class MediaType {
    MEDIA_TYPE_AUDIO,
    MEDIA_TYPE_VIDEO
};

// 传输方向
enum class RtpDirection {
    k_send_recv,
    k_send_only,
    k_recv_only,
    k_inactive
};

// 连接方的角色信息 （setup 属性 ）
enum ConnectionRole {
    NONE = 0,
    ACTIVE,
    PASSIVE,
    ACTPASS,
    HOLDCONN
};

// 对应M行 公共部分
class MediaContentDescription {
public:
    virtual ~MediaContentDescription() {}
    virtual MediaType type() = 0;
    virtual std::string mid() = 0;

    // 获取编解码信息
    const std::vector<std::shared_ptr<CodecInfo>>& getCodecs() const {
        return m_codecs;
    }

    RtpDirection getDirection() const { return m_direction; }
    void setDirection(RtpDirection direction) { m_direction = direction; }

    bool getRtcpMux() const { return m_rtcp_mux; }
    void setRtcpMux(bool rtcp_mux) { m_rtcp_mux = rtcp_mux; }

    const std::vector<Candidate>& get_candidates() { 
        return m_candidates; 
    }

    void add_candidates(const std::vector<Candidate>& candidates) {
        m_candidates = candidates;
    }

protected:
    std::vector<std::shared_ptr<CodecInfo>> m_codecs; // 编解码器信息
    RtpDirection m_direction; // 传输方向
    bool m_rtcp_mux = true; // 是否复用 RTCP和RTCP在一个通道
    std::vector<Candidate> m_candidates; // ICE 候选地址
};

class AudioContentDescription : public MediaContentDescription {
public:
    // 初始化音频编解码信息
    AudioContentDescription();
    MediaType type() override { return MediaType::MEDIA_TYPE_AUDIO; }
    std::string mid() override { return "audio"; }
};

class VideoContentDescription : public MediaContentDescription {
public:
    // 初始化视频编解码信息
    VideoContentDescription();
    MediaType type() override { return MediaType::MEDIA_TYPE_VIDEO; }
    std::string mid() override { return "video"; }
};

// 内容分组
class ContentGroup {
public:
    ContentGroup(const std::string& semantics) : m_semantics(semantics) {}
    ~ContentGroup() = default;

    // 获取分组名
    std::string getSemantics() const { return m_semantics; }
    const std::vector<std::string>& getContentNames() const { return m_content_names; }
    bool hasContentName(const std::string& content_name);
    void addContentName(const std::string& content_name);

private:
    std::string m_semantics; // 分组名
    std::vector<std::string> m_content_names; // audio /  video 名称
};


// ICE的传输信息
class TransportDescription {
public:

public:
    std::string m_mid; // 媒体类型 （audio / video）
    std::string m_ICE_ufrag; // ICE 用户名片
    std::string m_ICE_pwd; // ICE 密码
    std::unique_ptr<rtc::SSLFingerprint> m_identity_fingerprint; // 身份证书指纹
    ConnectionRole m_connection_role = ConnectionRole::NONE; // 连接方的角色信息 （setup 属性 ）
};

// sdp描述信息
class SessionDescription {
public:
    SessionDescription(SdpType type) : m_sdp_type(type) {}
    ~SessionDescription() = default;

    void addContent(std::shared_ptr<MediaContentDescription> content);

    std::shared_ptr<MediaContentDescription> get_content(const std::string& mid);

    // 获取媒体描述信息
    const std::vector<std::shared_ptr<MediaContentDescription>>& getContents() const {
        return m_contents;
    }

    void addGroup(const ContentGroup& group);
    // 添加分组
    std::vector<const ContentGroup*> getGroupByName(const std::string& name) const;

    // 添加 ICE 传输信息，生成指纹校验
    bool addTransportInfo(const std::string& mid, const IceParameters& ice_param, 
                          rtc::RTCCertificate* certificate);
    void add_transport_info(std::shared_ptr<TransportDescription> td);

    // 获取ICE 传输信息
    std::shared_ptr<TransportDescription> getTransportInfo(const std::string& mid);

    bool is_bundle(const std::string& mid);
    std::string get_first_bundle_mid();

    std::string toString();

private:
    SdpType m_sdp_type;
    std::vector<std::shared_ptr<MediaContentDescription>> m_contents; // 媒体描述信息
    std::vector<ContentGroup> m_content_groups; // 内容分组的集合
    std::vector<std::shared_ptr<TransportDescription>> m_transport_infos; // ICE 传输信息的集合
};
    

} // namespace xrtc